home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / pyshared / checkbox / reports / launchpad_report.py next >
Encoding:
Python Source  |  2009-04-27  |  10.2 KB  |  292 lines
  1. #
  2. # This file is part of Checkbox.
  3. #
  4. # Copyright 2008 Canonical Ltd.
  5. #
  6. # Checkbox is free software: you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation, either version 3 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # Checkbox is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
  18. #
  19. import logging
  20.  
  21. from time import strptime
  22. from datetime import datetime
  23.  
  24. from checkbox.report import Report
  25. from checkbox.reports.xml_report import (XmlReportManager, XmlReport,
  26.     convert_bool)
  27.  
  28.  
  29. class LaunchpadReportManager(XmlReportManager):
  30.  
  31.     def __init__(self, *args, **kwargs):
  32.         super(LaunchpadReportManager, self).__init__(*args, **kwargs)
  33.         self.add(ContextReport())
  34.         self.add(HalReport())
  35.         self.add(LsbReport())
  36.         self.add(PackagesReport())
  37.         self.add(ProcessorsReport())
  38.         self.add(SummaryReport())
  39.         self.add(QuestionsReport())
  40.  
  41.  
  42. class ContextReport(XmlReport):
  43.  
  44.     def register_dumps(self):
  45.         for (dt, dh) in [("context", self.dumps_context)]:
  46.             self._manager.handle_dumps(dt, dh)
  47.  
  48.     def register_loads(self):
  49.         for (lt, lh) in [("context", self.loads_context)]:
  50.             self._manager.handle_loads(lt, lh)
  51.  
  52.     def dumps_context(self, obj, parent):
  53.         logging.debug("Dumping context")
  54.         for info in obj:
  55.             element = self._create_element("info", parent)
  56.             element.setAttribute("command", info["command"])
  57.             self._create_text_node(info["data"], element)
  58.  
  59.     def loads_context(self, node):
  60.         logging.debug("Loading context")
  61.         context = []
  62.         for info in (i for i in node.childNodes if d.localName == "info"):
  63.             value = self._manager.call_loads(info)
  64.             context.append(value)
  65.  
  66.         return context
  67.  
  68.  
  69. class HalReport(XmlReport):
  70.     """Report for HAL related data types."""
  71.  
  72.     def register_dumps(self):
  73.         for (dt, dh) in [("hal", self.dumps_hal)]:
  74.             self._manager.handle_dumps(dt, dh)
  75.  
  76.     def register_loads(self):
  77.         for (lt, lh) in [("hal", self.loads_hal)]:
  78.             self._manager.handle_loads(lt, lh)
  79.  
  80.     def dumps_hal(self, obj, parent):
  81.         logging.debug("Dumping hal")
  82.         parent.setAttribute("version", obj["version"])
  83.         for device in obj["devices"].values():
  84.             element = self._create_element("device", parent)
  85.             element.setAttribute("id", str(device.id))
  86.             element.setAttribute("udi", device.info.udi)
  87.             self.dumps_device(device, element)
  88.  
  89.     def dumps_device(self, obj, parent, keys=[]):
  90.         from checkbox.registry import Registry
  91.  
  92.         for key, value in obj.items():
  93.             if isinstance(value, Registry):
  94.                 self.dumps_device(value, parent, keys + [key])
  95.             else:
  96.                 key = ".".join(keys + [key])
  97.                 self._manager.call_dumps({key: value}, parent)
  98.  
  99.     def loads_hal(self, node):
  100.         logging.debug("Loading hal")
  101.         hal = {}
  102.         hal["version"] = node.getAttribute("version")
  103.         hal["devices"] = []
  104.         for device in (d for d in node.childNodes if d.localName == "device"):
  105.             value = self._manager.call_loads(device)
  106.             hal["devices"].append(value)
  107.         return hal
  108.  
  109.  
  110. class LsbReport(Report):
  111.  
  112.     def register_dumps(self):
  113.         for (dt, dh) in [("lsbrelease", self.dumps_lsbrelease)]:
  114.             self._manager.handle_dumps(dt, dh)
  115.  
  116.     def dumps_lsbrelease(self, obj, parent):
  117.         logging.debug("Dumping lsbrelease")
  118.         for key, value in obj.items():
  119.             property = self._create_element("property", parent)
  120.             property.setAttribute("name", key)
  121.             self._manager.call_dumps(value, property)
  122.  
  123.  
  124. class PackagesReport(Report):
  125.     """Report for package related data types."""
  126.  
  127.     def register_dumps(self):
  128.         self._manager.handle_dumps("packages", self.dumps_packages)
  129.  
  130.     def register_loads(self):
  131.         self._manager.handle_loads("packages", self.loads_packages)
  132.  
  133.     def dumps_packages(self, obj, parent):
  134.         logging.debug("Dumping packages")
  135.         for package in obj:
  136.             element = self._create_element("package", parent)
  137.             element.setAttribute("id", str(package.id))
  138.  
  139.             package = dict(package)
  140.             element.setAttribute("name", package.pop("name"))
  141.             self._manager.call_dumps(package, element)
  142.  
  143.     def loads_packages(self, node):
  144.         logging.debug("Loading packages")
  145.         packages = []
  146.         for package in (p for p in node.childNodes if p.localName == "package"):
  147.             value = self._manager.call_loads(package)
  148.             value["name"] = package.getAttribute("name")
  149.             packages.append(value)
  150.  
  151.         return packages
  152.  
  153.  
  154. class ProcessorsReport(Report):
  155.     """Report for processor related data types."""
  156.  
  157.     def register_dumps(self):
  158.         self._manager.handle_dumps("processors", self.dumps_processors)
  159.  
  160.     def register_loads(self):
  161.         self._manager.handle_loads("processors", self.loads_processors)
  162.  
  163.     def dumps_processors(self, obj, parent):
  164.         logging.debug("Dumping processors")
  165.         for processor in obj:
  166.             element = self._create_element("processor", parent)
  167.             element.setAttribute("id", str(processor.id))
  168.  
  169.             processor = dict(processor)
  170.             element.setAttribute("name", str(processor.pop("name")))
  171.             self._manager.call_dumps(processor, element)
  172.  
  173.     def loads_processors(self, node):
  174.         logging.debug("Loading processors")
  175.         processors = []
  176.         for processor in (p for p in node.childNodes if p.localName == "processor"):
  177.             value = self._manager.call_loads(processor)
  178.             value["name"] = processor.getAttribute("name")
  179.             processors.append(value)
  180.  
  181.         return processors
  182.  
  183.  
  184. class SummaryReport(Report):
  185.     """Report for summary related data types."""
  186.  
  187.     def register_dumps(self):
  188.         for (dt, dh) in [("live_cd", self.dumps_value),
  189.                          ("system_id", self.dumps_value),
  190.                          ("distribution", self.dumps_value),
  191.                          ("distroseries", self.dumps_value),
  192.                          ("architecture", self.dumps_value),
  193.                          ("private", self.dumps_value),
  194.                          ("contactable", self.dumps_value),
  195.                          ("date_created", self.dumps_datetime),
  196.                          ("client", self.dumps_client)]:
  197.             self._manager.handle_dumps(dt, dh)
  198.  
  199.     def register_loads(self):
  200.         for (lt, lh) in [("live_cd", self.loads_bool),
  201.                          ("system_id", self.loads_str),
  202.                          ("distribution", self.loads_str),
  203.                          ("distroseries", self.loads_str),
  204.                          ("architecture", self.loads_str),
  205.                          ("private", self.loads_bool),
  206.                          ("contactable", self.loads_bool),
  207.                          ("date_created", self.loads_datetime),
  208.                          ("client", self.loads_client)]:
  209.             self._manager.handle_loads(lt, lh)
  210.  
  211.     def dumps_value(self, obj, parent):
  212.         parent.setAttribute("value", str(obj))
  213.  
  214.     def dumps_datetime(self, obj, parent):
  215.         parent.setAttribute("value", str(obj).split(".")[0])
  216.  
  217.     def dumps_client(self, obj, parent):
  218.         parent.setAttribute("name", obj["name"])
  219.         parent.setAttribute("version", obj["version"])
  220.  
  221.     def loads_bool(self, node):
  222.         return convert_bool(node.getAttribute("value"))
  223.  
  224.     def loads_str(self, node):
  225.         return str(node.getAttribute("value"))
  226.  
  227.     def loads_datetime(self, node):
  228.         value = node.getAttribute("value")
  229.         return datetime(*strptime(value, "%Y-%m-%dT%H:%M:%S")[0:7])
  230.  
  231.     def loads_client(self, node):
  232.         name = node.getAttribute("name")
  233.         version = node.getAttribute("version")
  234.         return {"name": name, "version": version}
  235.  
  236.  
  237. class QuestionsReport(Report):
  238.     """Report for question related data types."""
  239.  
  240.     def register_dumps(self):
  241.         for (dt, dh) in [("questions", self.dumps_questions)]:
  242.             self._manager.handle_dumps(dt, dh)
  243.  
  244.     def register_loads(self):
  245.         for (lt, lh) in [("questions", self.loads_questions),
  246.                          ("answer", self.loads_data),
  247.                          ("answer_choices", self.loads_none),
  248.                          ("comment", self.loads_data)]:
  249.             self._manager.handle_loads(lt, lh)
  250.  
  251.     def dumps_questions(self, obj, parent):
  252.         logging.debug("Dumping questions")
  253.         for question in obj:
  254.             element = self._create_element("question", parent)
  255.             element.setAttribute("name", question["name"])
  256.             self.dumps_answer(question["result"]["status"], element)
  257.             self.dumps_comment(question["result"]["data"], element)
  258.  
  259.     def dumps_answer(self, obj, parent):
  260.         from checkbox.test import ALL_STATUS
  261.  
  262.         answer = self._create_element("answer", parent)
  263.         answer.setAttribute("type", "multiple_choice")
  264.         self._create_text_node(str(obj), answer)
  265.  
  266.         answer_choices = self._create_element("answer_choices", parent)
  267.         for choice in ALL_STATUS:
  268.             value = self._create_element("value", answer_choices)
  269.             self._manager.call_dumps(choice, value)
  270.  
  271.     def dumps_comment(self, obj, parent):
  272.         comment = self._create_element("comment", parent)
  273.         self._create_text_node(str(obj), comment)
  274.  
  275.     def dumps_text(self, obj, parent):
  276.         self._create_text_node(str(obj), parent)
  277.  
  278.     def loads_questions(self, node):
  279.         logging.debug("Loading questions")
  280.         questions = []
  281.         for question in (q for q in node.childNodes if q.localName == "question"):
  282.             value = self._manager.call_loads(question)
  283.             value["name"] = question.getAttribute("name")
  284.             questions.append(value)
  285.         return questions
  286.  
  287.     def loads_none(self, node):
  288.         return None
  289.  
  290.     def loads_data(self, node):
  291.         return node.firstChild.data.strip()
  292.